{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kaggle环境版本检查:\n",
      "Python: 3.12.9\n",
      "XGBoost: 3.0.2\n",
      "CatBoost: 1.2.8\n",
      "LightGBM: 4.6.0\n",
      "PyTorch: 2.7.0+cu118\n",
      "TensorFlow: 2.18.0\n",
      "Pandas: 2.2.3\n",
      "Numpy: 2.0.2\n",
      "Scipy: 1.15.3\n",
      "Scikit-learn: 1.6.1\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "def get_version(lib_name, import_name=None):\n",
    "    try:\n",
    "        if import_name is None:\n",
    "            import_name = lib_name\n",
    "        lib = __import__(import_name)\n",
    "        return lib.__version__\n",
    "    except ImportError:\n",
    "        return '未安装'\n",
    "    except AttributeError:\n",
    "        return '无__version__属性'\n",
    "    except Exception as e:\n",
    "        return f'获取失败: {e}'\n",
    "\n",
    "# 获取Python版本\n",
    "python_version = sys.version.split(' ')[0]\n",
    "\n",
    "# 获取各库版本\n",
    "versions = {\n",
    "    \"Python\": python_version,\n",
    "    \"XGBoost\": get_version('xgboost'),\n",
    "    \"CatBoost\": get_version('catboost'),\n",
    "    \"LightGBM\": get_version('lightgbm'),\n",
    "    \"PyTorch\": get_version('torch'),\n",
    "    \"TensorFlow\": get_version('tensorflow'),\n",
    "    \"Pandas\": get_version('pandas'),\n",
    "    \"Numpy\": get_version('numpy'),\n",
    "    \"Scipy\": get_version('scipy'),\n",
    "    \"Scikit-learn\": get_version('sklearn'),\n",
    "}\n",
    "\n",
    "# 打印版本信息\n",
    "print(\"Kaggle环境版本检查:\")\n",
    "for lib, version in versions.items():\n",
    "    print(f\"{lib}: {version}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== 环境信息 =====\n",
      "Python 版本: 3.12.9\n",
      "Python 路径: c:\\Users\\fh\\.conda\\envs\\kaggle312\\python.exe\n",
      "工作目录: d:\\myWork\\kaggle_playground\n",
      "\n",
      "===== 深度学习框架 =====\n",
      "PyTorch 版本: 2.7.0+cu118\n",
      "CUDA 可用: True\n",
      "CUDA 版本: 11.8\n",
      "GPU 数量: 1\n",
      "当前 GPU: NVIDIA GeForce GTX 1650\n",
      "\n",
      "TensorFlow 未安装\n",
      "\n",
      "===== 梯度提升框架 =====\n",
      "\n",
      "LightGBM 版本: 4.6.0\n",
      "LightGBM GPU支持: 不可用 (Data list can only be of ndarray or Sequence)\n",
      "\n",
      "CatBoost 版本: 1.2.8\n",
      "CatBoost GPU支持: 可用\n",
      "\n",
      "XGBoost 版本: 3.0.2\n",
      "XGBoost GPU支持: 可用\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\fh\\.conda\\envs\\kaggle312\\Lib\\site-packages\\xgboost\\training.py:183: UserWarning: [15:18:01] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\common\\error_msg.cc:27: The tree method `gpu_hist` is deprecated since 2.0.0. To use GPU training, set the `device` parameter to CUDA instead.\n",
      "\n",
      "    E.g. tree_method = \"hist\", device = \"cuda\"\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n"
     ]
    }
   ],
   "source": [
    "import importlib.metadata\n",
    "import platform\n",
    "import sys\n",
    "import os\n",
    "\n",
    "\n",
    "def safe_print(msg):\n",
    "    try:\n",
    "        print(msg)\n",
    "    except Exception as e:\n",
    "        print(f\"打印信息失败: {e}\")\n",
    "\n",
    "def check_pytorch():\n",
    "    try:\n",
    "        import torch \n",
    "        torch_version = importlib.metadata.version('torch')\n",
    "        safe_print(f\"PyTorch 版本: {torch_version}\")\n",
    "        safe_print(f\"CUDA 可用: {torch.cuda.is_available()}\")\n",
    "        safe_print(f\"CUDA 版本: {torch.version.cuda if hasattr(torch.version, 'cuda') else 'N/A'}\")\n",
    "        safe_print(f\"GPU 数量: {torch.cuda.device_count()}\")\n",
    "        if torch.cuda.is_available():\n",
    "            safe_print(f\"当前 GPU: {torch.cuda.get_device_name(0)}\")\n",
    "    except importlib.metadata.PackageNotFoundError:\n",
    "        safe_print(\"PyTorch 未安装\")\n",
    "    except Exception as e:\n",
    "        safe_print(f\"检测 PyTorch 时发生异常: {e}\")\n",
    "\n",
    "def check_tensorflow():\n",
    "    try:\n",
    "        tf_version = importlib.metadata.version('tensorflow')\n",
    "        safe_print(f\"\\nTensorFlow 版本: {tf_version}\")\n",
    "        try:\n",
    "            import tensorflow as tf\n",
    "            try:\n",
    "                gpu_devices = tf.config.list_physical_devices('GPU')\n",
    "                safe_print(f\"GPU 设备: {len(gpu_devices)}\")\n",
    "                if gpu_devices:\n",
    "                    safe_print(\"GPU 支持: 可用\")\n",
    "                    safe_print(f\"当前 GPU: {tf.test.gpu_device_name() or 'N/A'}\")\n",
    "                    try:\n",
    "                        with tf.device('/GPU:0'):\n",
    "                            a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3])\n",
    "                            b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2])\n",
    "                            c = tf.matmul(a, b)\n",
    "                        safe_print(\"GPU 计算测试: 通过\")\n",
    "                    except Exception as e:\n",
    "                        safe_print(f\"GPU 计算测试: 失败 ({str(e)})\")\n",
    "                else:\n",
    "                    safe_print(\"GPU 支持: 不可用\")\n",
    "                    safe_print(\"可用设备:\")\n",
    "                    for device in tf.config.list_physical_devices():\n",
    "                        safe_print(f\"- {device.name} ({device.device_type})\")\n",
    "            except Exception as e:\n",
    "                safe_print(f\"检测 TensorFlow GPU 时发生异常: {e}\")\n",
    "        except Exception as e:\n",
    "            safe_print(f\"导入 tensorflow 失败: {e}\")\n",
    "    except importlib.metadata.PackageNotFoundError:\n",
    "        safe_print(\"\\nTensorFlow 未安装\")\n",
    "    except Exception as e:\n",
    "        safe_print(f\"检测 TensorFlow 时发生异常: {e}\")\n",
    "        \n",
    "def check_lightgbm():\n",
    "    try:\n",
    "        lgb_version = importlib.metadata.version('lightgbm')\n",
    "        safe_print(f\"\\nLightGBM 版本: {lgb_version}\")\n",
    "        try:\n",
    "            import lightgbm as lgb\n",
    "            try:\n",
    "                params = {'device': 'gpu', 'gpu_platform_id': 0, 'gpu_device_id': 0}\n",
    "                train_data = lgb.Dataset([[1]], label=[0])\n",
    "                lgb.train(params, train_data, num_boost_round=1)\n",
    "                safe_print(\"LightGBM GPU支持: 可用\")\n",
    "            except Exception as e:\n",
    "                safe_print(f\"LightGBM GPU支持: 不可用 ({str(e)})\")\n",
    "        except Exception as e:\n",
    "            safe_print(f\"导入 lightgbm 失败: {e}\")\n",
    "    except importlib.metadata.PackageNotFoundError:\n",
    "        safe_print(\"\\nLightGBM 未安装\")\n",
    "    except Exception as e:\n",
    "        safe_print(f\"检测 LightGBM 时发生异常: {e}\")\n",
    "\n",
    "def check_catboost():\n",
    "    try:\n",
    "        cb_version = importlib.metadata.version('catboost')\n",
    "        safe_print(f\"\\nCatBoost 版本: {cb_version}\")\n",
    "        try:\n",
    "            from catboost import CatBoostClassifier\n",
    "            try:\n",
    "                model = CatBoostClassifier(task_type='GPU')\n",
    "                safe_print(\"CatBoost GPU支持: 可用\")\n",
    "            except Exception as e:\n",
    "                safe_print(f\"CatBoost GPU支持: 不可用 ({str(e)})\")\n",
    "        except Exception as e:\n",
    "            safe_print(f\"导入 catboost 失败: {e}\")\n",
    "    except importlib.metadata.PackageNotFoundError:\n",
    "        safe_print(\"\\nCatBoost 未安装\")\n",
    "    except Exception as e:\n",
    "        safe_print(f\"检测 CatBoost 时发生异常: {e}\")\n",
    "\n",
    "def check_xgboost():\n",
    "    try:\n",
    "        xgb_version = importlib.metadata.version('xgboost')\n",
    "        safe_print(f\"\\nXGBoost 版本: {xgb_version}\")\n",
    "        try:\n",
    "            import xgboost as xgb\n",
    "            try:\n",
    "                params = {'tree_method': 'gpu_hist'}\n",
    "                xgb.train(params, xgb.DMatrix([[1]], label=[0]), num_boost_round=1)\n",
    "                safe_print(\"XGBoost GPU支持: 可用\")\n",
    "            except Exception as e:\n",
    "                safe_print(f\"XGBoost GPU支持: 不可用 ({str(e)})\")\n",
    "        except Exception as e:\n",
    "            safe_print(f\"导入 xgboost 失败: {e}\")\n",
    "    except importlib.metadata.PackageNotFoundError:\n",
    "        safe_print(\"\\nXGBoost 未安装\")\n",
    "    except Exception as e:\n",
    "        safe_print(f\"检测 XGBoost 时发生异常: {e}\")\n",
    "\n",
    "\n",
    "def main():\n",
    "    try:\n",
    "        safe_print(\"===== 环境信息 =====\")\n",
    "        safe_print(f\"Python 版本: {platform.python_version()}\")\n",
    "        safe_print(f\"Python 路径: {sys.executable}\")\n",
    "        safe_print(f\"工作目录: {os.getcwd()}\\n\")\n",
    "        \n",
    "        safe_print(\"===== 深度学习框架 =====\")\n",
    "        check_pytorch()\n",
    "        check_tensorflow()\n",
    "        \n",
    "        safe_print(\"\\n===== 梯度提升框架 =====\")\n",
    "        check_lightgbm()\n",
    "        check_catboost()\n",
    "        check_xgboost()\n",
    "    except Exception as e:\n",
    "        safe_print(f\"主流程发生异常: {e}\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Info] Number of positive: 499494, number of negative: 500506\n",
      "[LightGBM] [Info] Auto-choosing col-wise multi-threading, the overhead of testing was 0.384579 seconds.\n",
      "You can set `force_col_wise=true` to remove the overhead.\n",
      "[LightGBM] [Info] Total Bins 25500\n",
      "[LightGBM] [Info] Number of data points in the train set: 1000000, number of used features: 100\n",
      "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.499494 -> initscore=-0.002024\n",
      "[LightGBM] [Info] Start training from score -0.002024\n",
      "CPU 训练时间: 13.90 秒\n",
      "[LightGBM] [Info] Number of positive: 499494, number of negative: 500506\n",
      "[LightGBM] [Info] This is the GPU trainer!!\n",
      "[LightGBM] [Info] Total Bins 25500\n",
      "[LightGBM] [Info] Number of data points in the train set: 1000000, number of used features: 100\n",
      "[LightGBM] [Info] Using GPU Device: Intel(R) UHD Graphics 630, Vendor: Intel(R) Corporation\n",
      "[LightGBM] [Info] Compiling OpenCL Kernel with 256 bins...\n",
      "[LightGBM] [Info] GPU programs have been built\n",
      "[LightGBM] [Info] Size of histogram bin entry: 8\n",
      "[LightGBM] [Info] 100 dense feature groups (95.37 MB) transferred to GPU in 0.146990 secs. 0 sparse feature groups\n",
      "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.499494 -> initscore=-0.002024\n",
      "[LightGBM] [Info] Start training from score -0.002024\n",
      "GPU 训练时间: 21.83 秒\n"
     ]
    }
   ],
   "source": [
    "#是否支持 GPU 的进一步检查, 实际上是可以的。\n",
    "## 关于 LightGBM \n",
    "'''\n",
    "    # lightgbm                  4.6.0\n",
    "    lgb_params = {\n",
    "        'n_estimators': 1000,         # 增加树数量\n",
    "        'learning_rate': 0.02,        # 降低学习率\n",
    "        'max_depth': 6,               # 降低树深度，避免过深分裂\n",
    "        'num_leaves': 20,             # 减少叶子数，与 max_depth 配合\n",
    "        'subsample': 0.8,             # 随机采样部分样本\n",
    "        'colsample_bytree': 0.8,      # 随机采样部分特征\n",
    "        'reg_alpha': 1,               # L1正则化\n",
    "        'reg_lambda': 2,              # L2正则化\n",
    "        'random_state': 42,\n",
    "        'device': 'gpu',              # 使用GPU加速\n",
    "        'gpu_platform_id': 1,         # GPU平台ID， 我的机器有两个显卡，Intel默认是0，注意调整。\n",
    "        'gpu_device_id': 0,           # GPU设备ID\n",
    "        'min_child_samples': 30       # 增加每个叶子节点的最小样本数\n",
    "    }\n",
    "'''\n",
    "\n",
    "import lightgbm as lgb\n",
    "import numpy as np\n",
    "from time import time\n",
    "\n",
    "# 生成大数据集\n",
    "X = np.random.rand(1000000, 100)\n",
    "y = np.random.randint(0, 2, 1000000)\n",
    "\n",
    "# CPU 训练\n",
    "params_cpu = {'objective': 'binary', 'tree_learner': 'serial'}\n",
    "t0 = time()\n",
    "lgb.train(params_cpu, lgb.Dataset(X, y), 100)\n",
    "print(f\"CPU 训练时间: {time() - t0:.2f} 秒\")\n",
    "\n",
    "# GPU 训练\n",
    "# params_gpu = {'objective': 'binary', 'device': 'gpu', 'tree_learner': 'gpu_hist'}\n",
    "params_gpu = {'objective': 'binary', 'device': 'gpu'}\n",
    "t0 = time()\n",
    "lgb.train(params_gpu, lgb.Dataset(X, y), 100)\n",
    "print(f\"GPU 训练时间: {time() - t0:.2f} 秒\") \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 中文显示测试"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "检查 matplotlib， seaborn， plotly 是否安装，检查中文是否能正常显示"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== 库安装检查 =====\n",
      "matplotlib: 已安装 (3.10.3)\n",
      "plotly: 已安装 (6.1.2)\n",
      "\n",
      "===== 中文显示测试 =====\n",
      "\n",
      "--- Matplotlib 测试 ---\n",
      "Matplotlib 图形已生成，请查看是否能正常显示中文\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Plotly 测试 ---\n",
      "Plotly 图形已生成，请查看是否能正常显示中文\n"
     ]
    },
    {
     "data": {
      "application/vnd.plotly.v1+json": {
       "config": {
        "plotlyServerURL": "https://plot.ly"
       },
       "data": [
        {
         "mode": "lines",
         "name": "tan(x)",
         "type": "scatter",
         "x": {
          "bdata": "AAAAAAAAAAAxb2dIzNu5PzFvZ0jM28k/ZZNNNtlk0z8xb2dIzNvZP3+lQK1fKeA/ZZNNNtlk4z9LgVq/UqDmPzFvZ0jM2+k/F1100UUX7T9/pUCtXynwP3Icx3Ecx/E/ZZNNNtlk8z9YCtT6lQL1P0uBWr9SoPY/Pvjggw8++D8xb2dIzNv5PyTm7QyJefs/F1100UUX/T8K1PqVArX+P3+lQK1fKQBA+OCDDz74AEByHMdxHMcBQOtXCtT6lQJAZZNNNtlkA0DezpCYtzMEQFgK1PqVAgVA0UUXXXTRBUBLgVq/UqAGQMS8nSExbwdAPvjggw8+CEC3MyTm7QwJQDFvZ0jM2wlAq6qqqqqqCkAk5u0MiXkLQJ4hMW9nSAxAF1100UUXDUCRmLczJOYNQArU+pUCtQ5AhA8++OCDD0B/pUCtXykQQDtDYt7OkBBA+OCDDz74EEC1fqVArV8RQHIcx3EcxxFALrrooosuEkDrVwrU+pUSQKj1KwVq/RJAZZNNNtlkE0AiMW9nSMwTQN7OkJi3MxRAm2yyySabFEBYCtT6lQIVQBWo9SsFahVA0UUXXXTRFUCO4ziO4zgWQEuBWr9SoBZACB988MEHF0DEvJ0hMW8XQIFav1Kg1hdAPvjggw8+GED7lQK1fqUYQLczJObtDBlAdNFFF110GUAxb2dIzNsZQO4MiXk7QxpAq6qqqqqqGkBnSMzbGRIbQCTm7QyJeRtA4YMPPvjgG0CeITFvZ0gcQFq/UqDWrxxAF1100UUXHUDU+pUCtX4dQJGYtzMk5h1ATTbZZJNNHkAK1PqVArUeQMdxHMdxHB9AhA8++OCDH0BArV8pUOsfQH+lQK1fKSBAXXTRRRddIEA7Q2LezpAgQBoS83aGxCBA+OCDDz74IEDXrxSo9SshQLV+pUCtXyFAk0022WSTIUByHMdxHMchQFDrVwrU+iFALrrooosuIkANiXk7Q2IiQOtXCtT6lSJAyiabbLLJIkCo9SsFav0iQIbEvJ0hMSNAZZNNNtlkI0BDYt7OkJgjQCIxb2dIzCNAAAAAAAAAJEA=",
          "dtype": "f8"
         },
         "xaxis": "x",
         "y": {
          "bdata": "AAAAAAAAAABFNxd+Z/K5PwSymlJZN8o/+yn+mJ0C1D8AKlGNNV3bP/L7aUAuseE/J6fGo6Mt5j/vuy1fo1frP7IWWIcpvvA/EM8zYBiL9D+VxkSDI3v5P9/1jDTmKABABdTqyutWBUD+uskpn1sOQOzDSvUZUxlAQtLM+dvzMUA55OyQNQc2wBdwZ1utIRvAsIAQtACtD8DfIS0LlwYGwEVg4JoflgDA2wMJHYQS+r+i0XmYG/z0v3LDZ7BVF/G/MjbLz5/q67+Ize2xMqvmv7QZNoLDH+K/az306U0l3L9SEzEfGrzUv3rndTsSl8u/6aoZzbybvL8oEEa5ng2Fv+0EZEV9Src/GG/CxRrZyD+gbwJWUUrTP1yHb4Pdlto/TdoH+NhD4T8Xau9c27HlP/97XjQ2x+o/JubZReNm8D+SUibuBh30PzKa8Faj6Pg/36Wx2DyA/z9WndsHobAEQIzONxaTIw1AZLsZ8w69F0DI/pSvOUsuQHPi22ZpfTzACUcqrpg1HcCxmRzHgY0QwJRe+g9+wAbANuJ23BoIAcBj8P0kDa/6vxdXxJw1cPW/rFDow3xy8b9S7LJERYDsv4goBlWZKue/3Y+KWKSP4r+C3PSIN+/cvw/I+/7TdtW/Ds3zDVv4zL/eAmlRo0a/v0zWe4swDpW/3n3QU9ijtD+fTlteQXzHP1W8Yosok9I/WpNdWDXS2T9h0flyuNfgP6IqL7nJN+U/kt0muj856j/YcyD/bhHwP9pFkXPEsfM/yHkMq8Ba+D9Cez3D/bb+PwEBjj7zEgRAbXniUg0CDEArEPG4tVUWQKEenEHPMSpA+sMXvO4mRMA24TI8258fwHpm10LGVBHA5JxqnpeFB8DhBX/lL38BwMX1yS0MUfu/tqYw2I3n9b+VPGjutM/xvwa1L7iuGO2/DWOmDemr579VAdnI3ADjvwJD39sDu92/XCZCntgy1r+cnE20SVvOv+PpPcGg+cC/MOtRfrWWn7+asHUhU/6xPypQgTe4IMY/6xb1tRbd0T+xitsNLQ/ZPyHTMdvBbOA/gje+NF+/5D8=",
          "dtype": "f8"
         },
         "yaxis": "y"
        }
       ],
       "layout": {
        "annotations": [
         {
          "font": {
           "size": 16
          },
          "showarrow": false,
          "text": "P",
          "x": 0.5,
          "xanchor": "center",
          "xref": "paper",
          "y": 1,
          "yanchor": "bottom",
          "yref": "paper"
         }
        ],
        "height": 500,
        "template": {
         "data": {
          "bar": [
           {
            "error_x": {
             "color": "#2a3f5f"
            },
            "error_y": {
             "color": "#2a3f5f"
            },
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "bar"
           }
          ],
          "barpolar": [
           {
            "marker": {
             "line": {
              "color": "#E5ECF6",
              "width": 0.5
             },
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "barpolar"
           }
          ],
          "carpet": [
           {
            "aaxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "baxis": {
             "endlinecolor": "#2a3f5f",
             "gridcolor": "white",
             "linecolor": "white",
             "minorgridcolor": "white",
             "startlinecolor": "#2a3f5f"
            },
            "type": "carpet"
           }
          ],
          "choropleth": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "choropleth"
           }
          ],
          "contour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "contour"
           }
          ],
          "contourcarpet": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "contourcarpet"
           }
          ],
          "heatmap": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "heatmap"
           }
          ],
          "histogram": [
           {
            "marker": {
             "pattern": {
              "fillmode": "overlay",
              "size": 10,
              "solidity": 0.2
             }
            },
            "type": "histogram"
           }
          ],
          "histogram2d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2d"
           }
          ],
          "histogram2dcontour": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "histogram2dcontour"
           }
          ],
          "mesh3d": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "type": "mesh3d"
           }
          ],
          "parcoords": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "parcoords"
           }
          ],
          "pie": [
           {
            "automargin": true,
            "type": "pie"
           }
          ],
          "scatter": [
           {
            "fillpattern": {
             "fillmode": "overlay",
             "size": 10,
             "solidity": 0.2
            },
            "type": "scatter"
           }
          ],
          "scatter3d": [
           {
            "line": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatter3d"
           }
          ],
          "scattercarpet": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattercarpet"
           }
          ],
          "scattergeo": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergeo"
           }
          ],
          "scattergl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattergl"
           }
          ],
          "scattermap": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattermap"
           }
          ],
          "scattermapbox": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scattermapbox"
           }
          ],
          "scatterpolar": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolar"
           }
          ],
          "scatterpolargl": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterpolargl"
           }
          ],
          "scatterternary": [
           {
            "marker": {
             "colorbar": {
              "outlinewidth": 0,
              "ticks": ""
             }
            },
            "type": "scatterternary"
           }
          ],
          "surface": [
           {
            "colorbar": {
             "outlinewidth": 0,
             "ticks": ""
            },
            "colorscale": [
             [
              0,
              "#0d0887"
             ],
             [
              0.1111111111111111,
              "#46039f"
             ],
             [
              0.2222222222222222,
              "#7201a8"
             ],
             [
              0.3333333333333333,
              "#9c179e"
             ],
             [
              0.4444444444444444,
              "#bd3786"
             ],
             [
              0.5555555555555556,
              "#d8576b"
             ],
             [
              0.6666666666666666,
              "#ed7953"
             ],
             [
              0.7777777777777778,
              "#fb9f3a"
             ],
             [
              0.8888888888888888,
              "#fdca26"
             ],
             [
              1,
              "#f0f921"
             ]
            ],
            "type": "surface"
           }
          ],
          "table": [
           {
            "cells": {
             "fill": {
              "color": "#EBF0F8"
             },
             "line": {
              "color": "white"
             }
            },
            "header": {
             "fill": {
              "color": "#C8D4E3"
             },
             "line": {
              "color": "white"
             }
            },
            "type": "table"
           }
          ]
         },
         "layout": {
          "annotationdefaults": {
           "arrowcolor": "#2a3f5f",
           "arrowhead": 0,
           "arrowwidth": 1
          },
          "autotypenumbers": "strict",
          "coloraxis": {
           "colorbar": {
            "outlinewidth": 0,
            "ticks": ""
           }
          },
          "colorscale": {
           "diverging": [
            [
             0,
             "#8e0152"
            ],
            [
             0.1,
             "#c51b7d"
            ],
            [
             0.2,
             "#de77ae"
            ],
            [
             0.3,
             "#f1b6da"
            ],
            [
             0.4,
             "#fde0ef"
            ],
            [
             0.5,
             "#f7f7f7"
            ],
            [
             0.6,
             "#e6f5d0"
            ],
            [
             0.7,
             "#b8e186"
            ],
            [
             0.8,
             "#7fbc41"
            ],
            [
             0.9,
             "#4d9221"
            ],
            [
             1,
             "#276419"
            ]
           ],
           "sequential": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ],
           "sequentialminus": [
            [
             0,
             "#0d0887"
            ],
            [
             0.1111111111111111,
             "#46039f"
            ],
            [
             0.2222222222222222,
             "#7201a8"
            ],
            [
             0.3333333333333333,
             "#9c179e"
            ],
            [
             0.4444444444444444,
             "#bd3786"
            ],
            [
             0.5555555555555556,
             "#d8576b"
            ],
            [
             0.6666666666666666,
             "#ed7953"
            ],
            [
             0.7777777777777778,
             "#fb9f3a"
            ],
            [
             0.8888888888888888,
             "#fdca26"
            ],
            [
             1,
             "#f0f921"
            ]
           ]
          },
          "colorway": [
           "#636efa",
           "#EF553B",
           "#00cc96",
           "#ab63fa",
           "#FFA15A",
           "#19d3f3",
           "#FF6692",
           "#B6E880",
           "#FF97FF",
           "#FECB52"
          ],
          "font": {
           "color": "#2a3f5f"
          },
          "geo": {
           "bgcolor": "white",
           "lakecolor": "white",
           "landcolor": "#E5ECF6",
           "showlakes": true,
           "showland": true,
           "subunitcolor": "white"
          },
          "hoverlabel": {
           "align": "left"
          },
          "hovermode": "closest",
          "mapbox": {
           "style": "light"
          },
          "paper_bgcolor": "white",
          "plot_bgcolor": "#E5ECF6",
          "polar": {
           "angularaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "radialaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "scene": {
           "xaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "yaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           },
           "zaxis": {
            "backgroundcolor": "#E5ECF6",
            "gridcolor": "white",
            "gridwidth": 2,
            "linecolor": "white",
            "showbackground": true,
            "ticks": "",
            "zerolinecolor": "white"
           }
          },
          "shapedefaults": {
           "line": {
            "color": "#2a3f5f"
           }
          },
          "ternary": {
           "aaxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "baxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           },
           "bgcolor": "#E5ECF6",
           "caxis": {
            "gridcolor": "white",
            "linecolor": "white",
            "ticks": ""
           }
          },
          "title": {
           "x": 0.05
          },
          "xaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          },
          "yaxis": {
           "automargin": true,
           "gridcolor": "white",
           "linecolor": "white",
           "ticks": "",
           "title": {
            "standoff": 15
           },
           "zerolinecolor": "white",
           "zerolinewidth": 2
          }
         }
        },
        "title": {
         "text": "Plotly 中文测试"
        },
        "width": 800,
        "xaxis": {
         "anchor": "y",
         "domain": [
          0,
          1
         ],
         "title": {
          "text": "X 轴"
         }
        },
        "yaxis": {
         "anchor": "x",
         "domain": [
          0,
          1
         ],
         "title": {
          "text": "Y 轴"
         }
        }
       }
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import importlib.util\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import plotly.graph_objects as go\n",
    "from plotly.subplots import make_subplots\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 设置中文字体\n",
    "'''\n",
    "SimHei：Windows 系统默认黑体\n",
    "WenQuanYi Micro Hei：Linux 系统常用字体\n",
    "Heiti TC：macOS 系统字体\n",
    "Microsoft YaHei：Windows 系统雅黑字体\n",
    "'''\n",
    "plt.rcParams[\"font.family\"] = [\"SimHei\"]\n",
    "plt.rcParams['axes.unicode_minus']=False    # 默认是使用Unicode负号，设置正常显示字符，如正常显示负号\n",
    "\n",
    "\n",
    "# 检查库是否安装\n",
    "def check_library_installed(library_name):\n",
    "    \"\"\"检查指定的库是否已安装\"\"\"\n",
    "    spec = importlib.util.find_spec(library_name)\n",
    "    if spec is None:\n",
    "        return False, None\n",
    "    else:\n",
    "        try:\n",
    "            module = importlib.import_module(library_name)\n",
    "            return True, module.__version__\n",
    "        except Exception:\n",
    "            return True, \"版本未知\"\n",
    "\n",
    "# 测试 matplotlib 中文显示\n",
    "def test_matplotlib():\n",
    "    plt.figure(figsize=(8, 5))\n",
    "    x = np.linspace(0, 10, 100)\n",
    "    y = np.sin(x)\n",
    "    \n",
    "    plt.plot(x, y)\n",
    "    plt.title(\"Matplotlib 中文测试：正弦曲线\")\n",
    "    plt.xlabel(\"X 轴\")\n",
    "    plt.ylabel(\"Y 轴\")\n",
    "    plt.grid(True)\n",
    "    \n",
    "    print(\"Matplotlib 图形已生成，请查看是否能正常显示中文\")\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# 测试 plotly 中文显示\n",
    "def test_plotly():\n",
    "    x = np.linspace(0, 10, 100)\n",
    "    y = np.tan(x)\n",
    "    \n",
    "    fig = make_subplots(rows=1, cols=1, \n",
    "                        subplot_titles=(\"Plotly 中文测试：正切曲线\"))\n",
    "    \n",
    "    fig.add_trace(\n",
    "        go.Scatter(x=x, y=y, mode='lines', name='tan(x)'),\n",
    "        row=1, col=1\n",
    "    )\n",
    "    \n",
    "    fig.update_layout(\n",
    "        title_text=\"Plotly 中文测试\",\n",
    "        xaxis_title=\"X 轴\",\n",
    "        yaxis_title=\"Y 轴\",\n",
    "        height=500,\n",
    "        width=800\n",
    "    )\n",
    "    \n",
    "    print(\"Plotly 图形已生成，请查看是否能正常显示中文\")\n",
    "    fig.show()\n",
    "\n",
    "def main():\n",
    "    # 检查库的安装情况\n",
    "    libraries = [\"matplotlib\", \"plotly\"]\n",
    "    print(\"===== 库安装检查 =====\")\n",
    "    for lib in libraries:\n",
    "        installed, version = check_library_installed(lib)\n",
    "        status = \"已安装\" if installed else \"未安装\"\n",
    "        print(f\"{lib}: {status} ({version if installed else '-'})\")\n",
    "    \n",
    "    print(\"\\n===== 中文显示测试 =====\")\n",
    "    \n",
    "    # 测试 matplotlib\n",
    "    if check_library_installed(\"matplotlib\")[0]:\n",
    "        print(\"\\n--- Matplotlib 测试 ---\")\n",
    "        test_matplotlib()\n",
    "    else:\n",
    "        print(\"\\nMatplotlib 未安装，跳过测试\")\n",
    "    \n",
    "    # 测试 plotly\n",
    "    if check_library_installed(\"plotly\")[0]:\n",
    "        print(\"\\n--- Plotly 测试 ---\")\n",
    "        test_plotly()\n",
    "    else:\n",
    "        print(\"\\nPlotly 未安装，跳过测试\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 进一步测试 seaborn 显示中文， 不知道上面的冲突在哪里"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# 设置图片清晰度\n",
    "# plt.rcParams[\"figure.dpi\"] = 300\n",
    "\n",
    "# 设置中文字体，这里使用SimHei，如果系统没有该字体，可能需要替换为其他中文字体\n",
    "# plt.rcParams[\"font.family\"] = [\"SimHei\"]\n",
    "sns.set(font=\"SimHei\")  # 直接指定字体名称\n",
    "\n",
    "# 创建示例数据\n",
    "data = {\n",
    "    \"水果\": [\"苹果\", \"香蕉\", \"橙子\", \"葡萄\", \"草莓\"],\n",
    "    \"销量\": [35, 25, 30, 20, 15]\n",
    "}\n",
    "\n",
    "# 创建DataFrame\n",
    "import pandas as pd\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# 使用seaborn绘制柱状图\n",
    "sns.barplot(x=\"水果\", y=\"销量\", data=df)\n",
    "\n",
    "# 添加标题和标签\n",
    "plt.title(\"水果销量柱状图\")\n",
    "plt.xlabel(\"水果名称\")\n",
    "plt.ylabel(\"销量（单位：kg）\")\n",
    "\n",
    "# 显示图形\n",
    "plt.show()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['FZSongKeBenXiuKaiS-R-GB',\n",
       " 'FZQingKeBenYueSongJF',\n",
       " 'FZQingKeBenYueSongS',\n",
       " 'FZShiGuangKeSongS',\n",
       " 'MF KeSong(Noncommercial)',\n",
       " 'Microsoft JhengHei',\n",
       " 'Microsoft YaHei',\n",
       " 'FZShiGuangKeSongK',\n",
       " 'Microsoft YaHei',\n",
       " 'MF KeSong(Noncommercial)',\n",
       " 'Microsoft YaHei',\n",
       " 'Microsoft JhengHei',\n",
       " 'FZSongKeBenXiuKai-R-GBK',\n",
       " 'FZQingKeBenYueSongS-R-GB',\n",
       " 'FangSong',\n",
       " 'FZQingKeBenYueSongJF',\n",
       " 'Microsoft JhengHei',\n",
       " 'SimHei',\n",
       " 'STSong']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from matplotlib.font_manager import fontManager\n",
    "[f.name for f in fontManager.ttflist if 'Hei' in f.name or 'Song' in f.name]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "kaggle312",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
